const express = require('express');
const router = express.Router();
const WordProcessor = require('../utils/wordProcessor');
const path = require('path');
const fs = require('fs');
const mammoth = require('mammoth'); // 用于 Word 转 HTML

/**
 * @swagger
 * /api/documents/generate:
 *   post:
 *     summary: 生成Word文档
 *     tags: [Documents]
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               templateName:
 *                 type: string
 *                 description: 模版文件名
 *               data:
 *                 type: object
 *                 description: 要填充的数据
 *               outputName:
 *                 type: string
 *                 description: 输出文件名
 *     responses:
 *       200:
 *         description: 文档生成成功
 *       400:
 *         description: 请求参数错误
 *       500:
 *         description: 服务器错误
 */
router.post('/generate', async (req, res) => {
  try {
    const { templateName = '模版.docx', data, outputName } = req.body;
    
    if (!data) {
      return res.status(400).json({
        code: 400,
        message: '缺少数据参数'
      });
    }
    
    const templatePath = path.join(__dirname, '../', templateName);
    const outputPath = path.join(__dirname, '../output/', outputName || `generated_${Date.now()}.docx`);
    
    // 确保输出目录存在
    const outputDir = path.dirname(outputPath);
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }
    
    const result = await WordProcessor.processTemplate(templatePath, data, outputPath);
    
    if (result.success) {
      res.json({
        code: 200,
        message: '文档生成成功',
        downloadUrl: `/api/documents/download/${path.basename(outputPath)}`
      });
    } else {
      res.status(500).json({
        code: 500,
        message: result.message || '文档生成失败'
      });
    }
  } catch (error) {
    console.error('生成文档时出错:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
});

/**
 * @swagger
 * /api/documents/batch-generate:
 *   post:
 *     summary: 批量生成Word文档
 *     tags: [Documents]
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               templateName:
 *                 type: string
 *                 description: 模版文件名
 *               dataList:
 *                 type: array
 *                 description: 数据列表
 *                 items:
 *                   type: object
 *     responses:
 *       200:
 *         description: 批量生成成功
 */
router.post('/batch-generate', async (req, res) => {
  try {
    const { templateName = '模版.docx', dataList } = req.body;
    
    if (!Array.isArray(dataList) || dataList.length === 0) {
      return res.status(400).json({
        code: 400,
        message: '数据列表不能为空'
      });
    }
    
    const templatePath = path.join(__dirname, '../', templateName);
    const outputDir = path.join(__dirname, '../output/batch/');
    
    // 确保输出目录存在
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }
    
    const results = await WordProcessor.batchProcess(templatePath, dataList, outputDir);
    
    res.json({
      code: 200,
      message: `批量生成完成，共处理 ${results.length} 个文档`,
      results
    });
  } catch (error) {
    console.error('批量生成文档时出错:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
});

/**
 * @swagger
 * /api/documents/download/{filename}:
 *   get:
 *     summary: 下载生成的文档
 *     tags: [Documents]
 *     parameters:
 *       - in: path
 *         name: filename
 *         required: true
 *         schema:
 *           type: string
 *         description: 文件名
 *     responses:
 *       200:
 *         description: 文件下载
 *         content:
 *           application/vnd.openxmlformats-officedocument.wordprocessingml.document:
 *             schema:
 *               type: string
 *               format: binary
 */
router.get('/download/:filename', (req, res) => {
  try {
    const filename = req.params.filename;
    const filePath = path.join(__dirname, '../output/', filename);
    
    if (!fs.existsSync(filePath)) {
      return res.status(404).json({
        code: 404,
        message: '文件不存在'
      });
    }
    
    res.download(filePath, filename, (err) => {
      if (err) {
        console.error('下载文件时出错:', err);
        res.status(500).json({
          code: 500,
          message: '下载失败'
        });
      }
    });
  } catch (error) {
    console.error('下载文件时出错:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
});

/**
 * @swagger
 * /api/documents/fileUpdate:
 *   post:
 *     summary: 更新现有文档
 *     tags: [Documents]
 *     requestBody:
 *       required: true
 *       content:
 *         application/json:
 *           schema:
 *             type: object
 *             properties:
 *               existingFilePath:
 *                 type: string
 *                 description: 现有文件路径（相对于output目录的路径）
 *               templateName:
 *                 type: string
 *                 description: 模版文件名
 *               data:
 *                 type: object
 *                 description: 新的要填充的数据
 *               outputName:
 *                 type: string
 *                 description: 可选的新输出文件名
 *     responses:
 *       200:
 *         description: 文档更新成功
 *       400:
 *         description: 请求参数错误
 *       404:
 *         description: 文件不存在
 *       500:
 *         description: 服务器错误
 */
router.post('/fileUpdate', async (req, res) => {
  try {
    const { existingFilePath, templateName = '模版.docx', data, outputName } = req.body;
    
    if (!existingFilePath) {
      return res.status(400).json({
        code: 400,
        message: '缺少现有文件路径参数'
      });
    }
    
    if (!data) {
      return res.status(400).json({
        code: 400,
        message: '缺少数据参数'
      });
    }
    
    // 获取完整的文件路径
    const oldFilePath = path.join(__dirname, '../output/', existingFilePath);
    
    // 检查文件是否存在
    if (!fs.existsSync(oldFilePath)) {
      return res.status(404).json({
        code: 404,
        message: '文件不存在'
      });
    }
    
    // 确定新的输出路径
    let newFilePath;
    if (outputName) {
      // 如果提供了新的输出名称，使用它
      newFilePath = path.join(__dirname, '../output/', outputName);
    } else {
      // 否则，覆盖现有文件
      newFilePath = oldFilePath;
    }
    
    // 确保输出目录存在
    const outputDir = path.dirname(newFilePath);
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }
    
    // 使用WordProcessor更新文档
    const templatePath = path.join(__dirname, '../', templateName);
    const result = await WordProcessor.processTemplate(templatePath, data, newFilePath);
    
    if (result.success) {
      // 如果是覆盖原文件，使用原文件路径；否则使用新文件路径
      const finalPath = outputName ? outputName : existingFilePath;
      res.json({
        code: 200,
        message: '文档更新成功',
        downloadUrl: `/api/documents/download/${finalPath}`
      });
    } else {
      res.status(500).json({
        code: 500,
        message: result.message || '文档更新失败'
      });
    }
  } catch (error) {
    console.error('更新文档时出错:', error);
    res.status(500).json({
      code: 500,
      message: '服务器内部错误'
    });
  }
});

module.exports = router;